home *** CD-ROM | disk | FTP | other *** search
/ The 640 MEG Shareware Studio 2 / The 640 Meg Shareware Studio CD-ROM Volume II (Data Express)(1993).ISO / os2 / pccts.zip / DLG_P.C < prev    next >
C/C++ Source or Header  |  1992-12-08  |  15KB  |  690 lines
  1. /*
  2.  * A n t l r  T r a n s l a t i o n  H e a d e r
  3.  *
  4.  * Terence Parr, Hank Dietz and Will Cohen: 1989-1992
  5.  * Purdue University Electrical Engineering
  6.  * ANTLR Version 1.06
  7.  */
  8. #include <stdio.h>
  9. #include <ctype.h>
  10. #include "dlg.h"
  11. #ifdef MEMCHK
  12. #include "trax.h"
  13. #else
  14. extern char *malloc();
  15. extern char *calloc();
  16. #endif
  17. #include "antlr.h"
  18. #include "tokens.h"
  19. #include "dlgdef.h"
  20. #include "mode.h"
  21. ANTLR_INFO
  22. int    action_no = 0;       /* keep track of actions outputed */
  23. int    nfa_allocated = 0; /* keeps track of number of nfa nodes */
  24. nfa_node *nfa_array = NULL;/* root of binary tree that stores nfa array */
  25. nfa_node nfa_model_node;   /* model to initialize new nodes */
  26. set    used_chars;       /* used to label trans. arcs */
  27. set    used_classes;       /* classes or chars used to label trans. arcs */
  28. set    normal_chars;       /* mask to get rid elements that aren't used
  29. in set */
  30. int    flag_paren = FALSE;
  31. int    flag_brace = FALSE;
  32. int    mode_counter = 0;  /* keep track of number of %%names */
  33.  
  34. #ifdef __STDC__
  35. void
  36. grammar()
  37. #else
  38. grammar()
  39. #endif
  40. {
  41.     zzRULE;
  42.     zzBLOCK(zztasp1);
  43.     zzMake0;
  44.     {
  45.     p_head(); func_action = FALSE;  
  46.     {
  47.         zzBLOCK(zztasp2);
  48.         zzMake0;
  49.         {
  50.         while ( (LA(1)==ACTION) ) {
  51.             zzmatch(ACTION); zzCONSUME;
  52.             zzLOOP(zztasp2);
  53.         }
  54.         zzEXIT(zztasp2);
  55.         }
  56.     }
  57.     start_states();
  58.     func_action = FALSE; p_tables(); p_tail();   
  59.     {
  60.         zzBLOCK(zztasp2);
  61.         zzMake0;
  62.         {
  63.         while ( (LA(1)==ACTION) ) {
  64.             zzmatch(ACTION); zzCONSUME;
  65.             zzLOOP(zztasp2);
  66.         }
  67.         zzEXIT(zztasp2);
  68.         }
  69.     }
  70.     zzmatch(1); zzCONSUME;
  71.     zzEXIT(zztasp1);
  72.     return;
  73. fail:
  74.     zzEXIT(zztasp1);
  75.     zzsyn(zzMissText, zzBadTok, "", zzMissSet, zzMissTok, zzErrk, zzBadText);
  76.     zzresynch(setwd1, 0x1);
  77.     }
  78. }
  79.  
  80. #ifdef __STDC__
  81. void
  82. start_states()
  83. #else
  84. start_states()
  85. #endif
  86. {
  87.     zzRULE;
  88.     zzBLOCK(zztasp1);
  89.     zzMake0;
  90.     {
  91.     {
  92.         zzBLOCK(zztasp2);
  93.         zzMake0;
  94.         {
  95.         if ( (LA(1)==PER_PER) ) {
  96.             zzmatch(PER_PER); zzCONSUME;
  97.             do_conversion();
  98.         }
  99.         else if ( (LA(1)==NAME_PER_PER) ) {
  100.             zzmatch(NAME_PER_PER); zzCONSUME;
  101.             do_conversion();
  102.             {
  103.                 zzBLOCK(zztasp3);
  104.                 zzMake0;
  105.                 {
  106.                 while ( (LA(1)==NAME_PER_PER) ) {
  107.                     zzmatch(NAME_PER_PER); zzCONSUME;
  108.                     do_conversion();
  109.                     zzLOOP(zztasp3);
  110.                 }
  111.                 zzEXIT(zztasp3);
  112.                 }
  113.             }
  114.         }
  115.         else {zzFAIL(1,zzerr1,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  116.         zzEXIT(zztasp2);
  117.         }
  118.     }
  119.     zzmatch(PER_PER); zzCONSUME;
  120.     zzEXIT(zztasp1);
  121.     return;
  122. fail:
  123.     zzEXIT(zztasp1);
  124.     zzsyn(zzMissText, zzBadTok, "", zzMissSet, zzMissTok, zzErrk, zzBadText);
  125.     zzresynch(setwd1, 0x2);
  126.     }
  127. }
  128.  
  129. #ifdef __STDC__
  130. void
  131. do_conversion()
  132. #else
  133. do_conversion()
  134. #endif
  135. {
  136.     zzRULE;
  137.     zzBLOCK(zztasp1);
  138.     zzMake0;
  139.     {
  140.     new_automaton_mode(); func_action = TRUE;  
  141.     rule_list();
  142.     dfa_class_nop[mode_counter] =
  143.     relabel(zzaArg(zztasp1,1 ).l,comp_level);
  144.     if (comp_level)
  145.     p_shift_table(mode_counter);
  146.     dfa_basep[mode_counter] = dfa_allocated+1;
  147.     make_dfa_model_node(dfa_class_nop[mode_counter]);
  148.     nfa_to_dfa(zzaArg(zztasp1,1 ).l);
  149.     ++mode_counter;
  150.     func_action = FALSE;
  151.     zzEXIT(zztasp1);
  152.     return;
  153. fail:
  154.     zzEXIT(zztasp1);
  155.     zzsyn(zzMissText, zzBadTok, "", zzMissSet, zzMissTok, zzErrk, zzBadText);
  156.     zzresynch(setwd1, 0x4);
  157.     }
  158. }
  159.  
  160. #ifdef __STDC__
  161. void
  162. rule_list()
  163. #else
  164. rule_list()
  165. #endif
  166. {
  167.     zzRULE;
  168.     zzBLOCK(zztasp1);
  169.     zzMake0;
  170.     {
  171.     if ( (setwd1[LA(1)]&0x8) ) {
  172.         rule();
  173.         zzaRet.l=zzaArg(zztasp1,1 ).l; zzaRet.r=zzaArg(zztasp1,1 ).r;  
  174.         {
  175.             zzBLOCK(zztasp2);
  176.             zzMake0;
  177.             {
  178.             while ( (setwd1[LA(1)]&0x10) ) {
  179.                 rule();
  180.                 {nfa_node *t1;
  181.                     t1 = new_nfa_node();
  182.                     (t1)->trans[0]=zzaRet.l;
  183.                     (t1)->trans[1]=zzaArg(zztasp2,1 ).l;
  184.                     /* all accept nodes "dead ends" */
  185.                     zzaRet.l=t1; zzaRet.r=NULL;
  186.                 }
  187.                 zzLOOP(zztasp2);
  188.             }
  189.             zzEXIT(zztasp2);
  190.             }
  191.         }
  192.     }
  193.     else if ( (setwd1[LA(1)]&0x20) ) {
  194.         zzaRet.l = new_nfa_node(); zzaRet.r = NULL;
  195.         warning("no regular expressions", zzline);
  196.     }
  197.     else {zzFAIL(1,zzerr2,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  198.     zzEXIT(zztasp1);
  199.     return;
  200. fail:
  201.     zzEXIT(zztasp1);
  202.     zzsyn(zzMissText, zzBadTok, "", zzMissSet, zzMissTok, zzErrk, zzBadText);
  203.     zzresynch(setwd1, 0x40);
  204.     }
  205. }
  206.  
  207. #ifdef __STDC__
  208. void
  209. rule()
  210. #else
  211. rule()
  212. #endif
  213. {
  214.     zzRULE;
  215.     zzBLOCK(zztasp1);
  216.     zzMake0;
  217.     {
  218.     if ( (setwd1[LA(1)]&0x80) ) {
  219.         reg_expr();
  220.         zzmatch(ACTION);
  221.         zzaRet.l=zzaArg(zztasp1,1 ).l; zzaRet.r=zzaArg(zztasp1,1 ).r; (zzaArg(zztasp1,1 ).r)->accept=action_no;  
  222.          zzCONSUME;
  223.     }
  224.     else if ( (LA(1)==ACTION) ) {
  225.         zzmatch(ACTION);
  226.         zzaRet.l = NULL; zzaRet.r = NULL;
  227.         error("no expression for action  ", zzline);
  228.          zzCONSUME;
  229.     }
  230.     else {zzFAIL(1,zzerr3,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  231.     zzEXIT(zztasp1);
  232.     return;
  233. fail:
  234.     zzEXIT(zztasp1);
  235.     zzsyn(zzMissText, zzBadTok, "", zzMissSet, zzMissTok, zzErrk, zzBadText);
  236.     zzresynch(setwd1, 0x100);
  237.     }
  238. }
  239.  
  240. #ifdef __STDC__
  241. void
  242. reg_expr()
  243. #else
  244. reg_expr()
  245. #endif
  246. {
  247.     zzRULE;
  248.     zzBLOCK(zztasp1);
  249.     zzMake0;
  250.     {
  251.     and_expr();
  252.     zzaRet.l=zzaArg(zztasp1,1 ).l; zzaRet.r=zzaArg(zztasp1,1 ).r;  
  253.     {
  254.         zzBLOCK(zztasp2);
  255.         zzMake0;
  256.         {
  257.         while ( (LA(1)==OR) ) {
  258.             zzmatch(OR); zzCONSUME;
  259.             and_expr();
  260.             {nfa_node *t1, *t2;
  261.                 t1 = new_nfa_node(); t2 = new_nfa_node();
  262.                 (t1)->trans[0]=zzaRet.l;
  263.                 (t1)->trans[1]=zzaArg(zztasp2,2 ).l;
  264.                 (zzaRet.r)->trans[1]=t2;
  265.                 (zzaArg(zztasp2,2 ).r)->trans[1]=t2;
  266.                 zzaRet.l=t1; zzaRet.r=t2;
  267.             }
  268.             zzLOOP(zztasp2);
  269.         }
  270.         zzEXIT(zztasp2);
  271.         }
  272.     }
  273.     zzEXIT(zztasp1);
  274.     return;
  275. fail:
  276.     zzEXIT(zztasp1);
  277.     zzsyn(zzMissText, zzBadTok, "", zzMissSet, zzMissTok, zzErrk, zzBadText);
  278.     zzresynch(setwd1, 0x200);
  279.     }
  280. }
  281.  
  282. #ifdef __STDC__
  283. void
  284. and_expr()
  285. #else
  286. and_expr()
  287. #endif
  288. {
  289.     zzRULE;
  290.     zzBLOCK(zztasp1);
  291.     zzMake0;
  292.     {
  293.     repeat_expr();
  294.     zzaRet.l=zzaArg(zztasp1,1 ).l; zzaRet.r=zzaArg(zztasp1,1 ).r;  
  295.     {
  296.         zzBLOCK(zztasp2);
  297.         zzMake0;
  298.         {
  299.         while ( (setwd1[LA(1)]&0x400) ) {
  300.             repeat_expr();
  301.             (zzaRet.r)->trans[1]=zzaArg(zztasp2,1 ).l; zzaRet.r=zzaArg(zztasp2,1 ).r;  
  302.             zzLOOP(zztasp2);
  303.         }
  304.         zzEXIT(zztasp2);
  305.         }
  306.     }
  307.     zzEXIT(zztasp1);
  308.     return;
  309. fail:
  310.     zzEXIT(zztasp1);
  311.     zzsyn(zzMissText, zzBadTok, "", zzMissSet, zzMissTok, zzErrk, zzBadText);
  312.     zzresynch(setwd1, 0x800);
  313.     }
  314. }
  315.  
  316. #ifdef __STDC__
  317. void
  318. repeat_expr()
  319. #else
  320. repeat_expr()
  321. #endif
  322. {
  323.     zzRULE;
  324.     zzBLOCK(zztasp1);
  325.     zzMake0;
  326.     {
  327.     if ( (setwd1[LA(1)]&0x1000) ) {
  328.         expr();
  329.         zzaRet.l=zzaArg(zztasp1,1 ).l; zzaRet.r=zzaArg(zztasp1,1 ).r;  
  330.         {
  331.             zzBLOCK(zztasp2);
  332.             zzMake0;
  333.             {
  334.             if ( (LA(1)==ZERO_MORE) ) {
  335.                 zzmatch(ZERO_MORE);
  336.                 {    nfa_node *t1,*t2;
  337.                     (zzaRet.r)->trans[0] = zzaRet.l;
  338.                     t1 = new_nfa_node(); t2 = new_nfa_node();
  339.                     t1->trans[0]=zzaRet.l;
  340.                     t1->trans[1]=t2;
  341.                     (zzaRet.r)->trans[1]=t2;
  342.                     zzaRet.l=t1;zzaRet.r=t2;
  343.                 }
  344.                  zzCONSUME;
  345.             }
  346.             else if ( (LA(1)==ONE_MORE) ) {
  347.                 zzmatch(ONE_MORE);
  348.                 (zzaRet.r)->trans[0] = zzaRet.l;  
  349.                  zzCONSUME;
  350.             }
  351.             zzEXIT(zztasp2);
  352.             }
  353.         }
  354.     }
  355.     else if ( (LA(1)==ZERO_MORE) ) {
  356.         zzmatch(ZERO_MORE);
  357.         error("no expression for *", zzline);  
  358.          zzCONSUME;
  359.     }
  360.     else if ( (LA(1)==ONE_MORE) ) {
  361.         zzmatch(ONE_MORE);
  362.         error("no expression for +", zzline);  
  363.          zzCONSUME;
  364.     }
  365.     else {zzFAIL(1,zzerr4,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  366.     zzEXIT(zztasp1);
  367.     return;
  368. fail:
  369.     zzEXIT(zztasp1);
  370.     zzsyn(zzMissText, zzBadTok, "", zzMissSet, zzMissTok, zzErrk, zzBadText);
  371.     zzresynch(setwd1, 0x2000);
  372.     }
  373. }
  374.  
  375. #ifdef __STDC__
  376. void
  377. expr()
  378. #else
  379. expr()
  380. #endif
  381. {
  382.     zzRULE;
  383.     zzBLOCK(zztasp1);
  384.     zzMake0;
  385.     {
  386.     if ( (LA(1)==L_BRACK) ) {
  387.         zzmatch(L_BRACK); zzCONSUME;
  388.         atom_list();
  389.         zzmatch(R_BRACK);
  390.         zzaRet.l = new_nfa_node(); zzaRet.r = new_nfa_node();
  391.         (zzaRet.l)->trans[0] = zzaRet.r;
  392.         (zzaRet.l)->label = set_dup(zzaArg(zztasp1,2 ).label);
  393.         set_orin(&used_chars,(zzaRet.l)->label);
  394.          zzCONSUME;
  395.     }
  396.     else if ( (LA(1)==NOT) ) {
  397.         zzmatch(NOT); zzCONSUME;
  398.         zzmatch(L_BRACK); zzCONSUME;
  399.         atom_list();
  400.         zzmatch(R_BRACK);
  401.         zzaRet.l = new_nfa_node(); zzaRet.r = new_nfa_node();
  402.         (zzaRet.l)->trans[0] = zzaRet.r;
  403.         (zzaRet.l)->label = set_dif(normal_chars,zzaArg(zztasp1,3 ).label);
  404.         set_orin(&used_chars,(zzaRet.l)->label);
  405.          zzCONSUME;
  406.     }
  407.     else if ( (LA(1)==L_PAR) ) {
  408.         zzmatch(L_PAR); zzCONSUME;
  409.         reg_expr();
  410.         zzmatch(R_PAR);
  411.         zzaRet.l = new_nfa_node(); zzaRet.r = new_nfa_node();
  412.         (zzaRet.l)->trans[0] = zzaArg(zztasp1,2 ).l;
  413.         (zzaArg(zztasp1,2 ).r)->trans[1] = zzaRet.r;
  414.          zzCONSUME;
  415.     }
  416.     else if ( (LA(1)==L_BRACE) ) {
  417.         zzmatch(L_BRACE); zzCONSUME;
  418.         reg_expr();
  419.         zzmatch(R_BRACE);
  420.         zzaRet.l = new_nfa_node(); zzaRet.r = new_nfa_node();
  421.         (zzaRet.l)->trans[0] = zzaArg(zztasp1,2 ).l;
  422.         (zzaRet.l)->trans[1] = zzaRet.r;
  423.         (zzaArg(zztasp1,2 ).r)->trans[1] = zzaRet.r;
  424.          zzCONSUME;
  425.     }
  426.     else if ( (setwd1[LA(1)]&0x4000) ) {
  427.         atom();
  428.         zzaRet.l = new_nfa_node(); zzaRet.r = new_nfa_node();
  429.         (zzaRet.l)->trans[0] = zzaRet.r;
  430.         (zzaRet.l)->label = set_dup(zzaArg(zztasp1,1 ).label);
  431.         set_orin(&used_chars,(zzaRet.l)->label);
  432.     }
  433.     else {zzFAIL(1,zzerr5,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  434.     zzEXIT(zztasp1);
  435.     return;
  436. fail:
  437.     zzEXIT(zztasp1);
  438.     zzsyn(zzMissText, zzBadTok, "", zzMissSet, zzMissTok, zzErrk, zzBadText);
  439.     zzresynch(setwd1, 0x8000);
  440.     }
  441. }
  442.  
  443. #ifdef __STDC__
  444. void
  445. atom_list()
  446. #else
  447. atom_list()
  448. #endif
  449. {
  450.     zzRULE;
  451.     zzBLOCK(zztasp1);
  452.     zzMake0;
  453.     {
  454.     set_free(zzaRet.label);   
  455.     {
  456.         zzBLOCK(zztasp2);
  457.         zzMake0;
  458.         {
  459.         while ( (setwd2[LA(1)]&0x1) ) {
  460.             near_atom();
  461.             set_orin(&(zzaRet.label),zzaArg(zztasp2,1 ).label);  
  462.             zzLOOP(zztasp2);
  463.         }
  464.         zzEXIT(zztasp2);
  465.         }
  466.     }
  467.     zzEXIT(zztasp1);
  468.     return;
  469. fail:
  470.     zzEXIT(zztasp1);
  471.     zzsyn(zzMissText, zzBadTok, "", zzMissSet, zzMissTok, zzErrk, zzBadText);
  472.     zzresynch(setwd2, 0x2);
  473.     }
  474. }
  475.  
  476. #ifdef __STDC__
  477. void
  478. near_atom()
  479. #else
  480. near_atom()
  481. #endif
  482. {
  483.     zzRULE;
  484.     zzBLOCK(zztasp1);
  485.     zzMake0;
  486.     {
  487.     register int i;
  488.     register int i_prime;
  489.     anychar();
  490.     zzaRet.letter=zzaArg(zztasp1,1 ).letter; zzaRet.label=set_of(zzaArg(zztasp1,1 ).letter);
  491.     i_prime = zzaArg(zztasp1,1 ).letter + MIN_CHAR;
  492.     if (case_insensitive && islower(i_prime))
  493.     set_orel(toupper(i_prime)-MIN_CHAR,
  494.     &(zzaRet.label));
  495.     if (case_insensitive && isupper(i_prime))
  496.     set_orel(tolower(i_prime)-MIN_CHAR,
  497.     &(zzaRet.label));
  498.     {
  499.         zzBLOCK(zztasp2);
  500.         zzMake0;
  501.         {
  502.         if ( (LA(1)==RANGE) ) {
  503.             zzmatch(RANGE); zzCONSUME;
  504.             anychar();
  505.             for (i=zzaRet.letter; i<= zzaArg(zztasp2,2 ).letter; ++i){
  506.                 set_orel(i,&(zzaRet.label));
  507.                 i_prime = i+MIN_CHAR;
  508.                 if (case_insensitive && islower(i_prime))
  509.                 set_orel(toupper(i_prime)-MIN_CHAR,
  510.                 &(zzaRet.label));
  511.                 if (case_insensitive && isupper(i_prime))
  512.                 set_orel(tolower(i_prime)-MIN_CHAR,
  513.                 &(zzaRet.label));
  514.             }
  515.         }
  516.         zzEXIT(zztasp2);
  517.         }
  518.     }
  519.     zzEXIT(zztasp1);
  520.     return;
  521. fail:
  522.     zzEXIT(zztasp1);
  523.     zzsyn(zzMissText, zzBadTok, "", zzMissSet, zzMissTok, zzErrk, zzBadText);
  524.     zzresynch(setwd2, 0x4);
  525.     }
  526. }
  527.  
  528. #ifdef __STDC__
  529. void
  530. atom()
  531. #else
  532. atom()
  533. #endif
  534. {
  535.     zzRULE;
  536.     zzBLOCK(zztasp1);
  537.     zzMake0;
  538.     {
  539.     register int i_prime;  
  540.     anychar();
  541.     zzaRet.label = set_of(zzaArg(zztasp1,1 ).letter);
  542.     i_prime = zzaArg(zztasp1,1 ).letter + MIN_CHAR;
  543.     if (case_insensitive && islower(i_prime))
  544.     set_orel(toupper(i_prime)-MIN_CHAR,
  545.     &(zzaRet.label));
  546.     if (case_insensitive && isupper(i_prime))
  547.     set_orel(tolower(i_prime)-MIN_CHAR,
  548.     &(zzaRet.label));
  549.     zzEXIT(zztasp1);
  550.     return;
  551. fail:
  552.     zzEXIT(zztasp1);
  553.     zzsyn(zzMissText, zzBadTok, "", zzMissSet, zzMissTok, zzErrk, zzBadText);
  554.     zzresynch(setwd2, 0x8);
  555.     }
  556. }
  557.  
  558. #ifdef __STDC__
  559. void
  560. anychar()
  561. #else
  562. anychar()
  563. #endif
  564. {
  565.     zzRULE;
  566.     zzBLOCK(zztasp1);
  567.     zzMake0;
  568.     {
  569.     if ( (LA(1)==REGCHAR) ) {
  570.         zzmatch(REGCHAR);
  571.         zzaRet.letter = zzaArg(zztasp1,1 ).letter - MIN_CHAR;  
  572.          zzCONSUME;
  573.     }
  574.     else if ( (LA(1)==OCTAL_VALUE) ) {
  575.         zzmatch(OCTAL_VALUE);
  576.         zzaRet.letter = zzaArg(zztasp1,1 ).letter - MIN_CHAR;  
  577.          zzCONSUME;
  578.     }
  579.     else if ( (LA(1)==HEX_VALUE) ) {
  580.         zzmatch(HEX_VALUE);
  581.         zzaRet.letter = zzaArg(zztasp1,1 ).letter - MIN_CHAR;  
  582.          zzCONSUME;
  583.     }
  584.     else if ( (LA(1)==DEC_VALUE) ) {
  585.         zzmatch(DEC_VALUE);
  586.         zzaRet.letter = zzaArg(zztasp1,1 ).letter - MIN_CHAR;  
  587.          zzCONSUME;
  588.     }
  589.     else if ( (LA(1)==TAB) ) {
  590.         zzmatch(TAB);
  591.         zzaRet.letter = zzaArg(zztasp1,1 ).letter - MIN_CHAR;  
  592.          zzCONSUME;
  593.     }
  594.     else if ( (LA(1)==NL) ) {
  595.         zzmatch(NL);
  596.         zzaRet.letter = zzaArg(zztasp1,1 ).letter - MIN_CHAR;  
  597.          zzCONSUME;
  598.     }
  599.     else if ( (LA(1)==CR) ) {
  600.         zzmatch(CR);
  601.         zzaRet.letter = zzaArg(zztasp1,1 ).letter - MIN_CHAR;  
  602.          zzCONSUME;
  603.     }
  604.     else if ( (LA(1)==BS) ) {
  605.         zzmatch(BS);
  606.         zzaRet.letter = zzaArg(zztasp1,1 ).letter - MIN_CHAR;  
  607.          zzCONSUME;
  608.     }
  609.     else if ( (LA(1)==LIT) ) {
  610.         zzmatch(LIT);
  611.         zzaRet.letter = zzaArg(zztasp1,1 ).letter - MIN_CHAR;  
  612.          zzCONSUME;
  613.     }
  614.     else if ( (LA(1)==L_EOF) ) {
  615.         zzmatch(L_EOF);
  616.         zzaRet.letter = 0;  
  617.          zzCONSUME;
  618.     }
  619.     else {zzFAIL(1,zzerr6,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  620.     zzEXIT(zztasp1);
  621.     return;
  622. fail:
  623.     zzEXIT(zztasp1);
  624.     /* empty action */  
  625.     zzsyn(zzMissText, zzBadTok, "", zzMissSet, zzMissTok, zzErrk, zzBadText);
  626.     zzresynch(setwd2, 0x10);
  627.     }
  628. }
  629. /* finds nfa state i in the binary tree nfa_array */
  630. nfa_node *index_nfa(i)
  631. register int i;
  632. {
  633.     register nfa_node *p = nfa_array;
  634.     if (i){
  635.         while((i>1) && p){
  636.             if(i & 1)
  637.             p = p->right;
  638.             else
  639.             p = p->left;
  640.             i = i>>1;
  641.         }
  642.         return p;
  643.     }else{
  644.         return NIL_INDEX;
  645.     }
  646. }
  647. /* adds a new nfa to the binary tree and returns a pointer to it */
  648. nfa_node *new_nfa_node()
  649. {
  650.     register nfa_node *p = nfa_array;
  651.     nfa_node *t;
  652.     register int i;
  653.     i = ++nfa_allocated;
  654.     t = (nfa_node*) malloc(sizeof(nfa_node));
  655.     *t = nfa_model_node;
  656.     t->node_no = i;
  657.     while((i>3) && p){
  658.         if(i & 1)
  659.         p = p->right;
  660.         else
  661.         p = p->left;
  662.         i = i>>1;
  663.     }
  664.     if (nfa_allocated == 1)
  665.     nfa_array = t;
  666.     else if (p != NIL_INDEX){
  667.         if (i & 1)
  668.         p->right = t;
  669.         else
  670.         p->left = t;
  671.     }
  672.     else{
  673.         internal_error("%s(%d): missing node on binary tree\n",
  674.         __FILE__,__LINE__);
  675.     }
  676.     return t;
  677. }
  678. /* initialize the model node used to fill in newly made nfa_nodes */
  679. make_nfa_model_node()
  680. {
  681.     nfa_model_node.left = NULL;
  682.     nfa_model_node.right = NULL;
  683.     nfa_model_node.node_no = -1; /* impossible value for real nfa node */
  684.     nfa_model_node.nfa_set = 0;
  685.     nfa_model_node.accept = 0;   /* error state default*/
  686.     nfa_model_node.trans[0] = NULL;
  687.     nfa_model_node.trans[1] = NULL;
  688.     nfa_model_node.label = empty;
  689. }
  690.